COMMENT ⊗   VALID 00015 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002	GENERAL
C00006 00003	DO <function> |  DO <program> |  DO If DO  is followed by  a function
C00013 00004	PARK
C00017 00005	OPEN <dist>
C00019 00006	FREE <n> <f1> ... <fn>
C00022 00007	CONO <arrive> <weight> <k> <ts> <tm>
C00025 00008	SAVE <id>
C00027 00009	 JUMP <label>
C00029 00010	ASSIGN <id> <integer>
C00032 00011	DEFINE <macro name> <par>
C00036 00012	This  is  a  programming  example.  We have the situation of the hand
C00040 00013		DEFINE	FIND	T D F		This macro is used to search
C00042 00014	ERRORS
C00044 00015	RUNNING THE ARM
C00048 ENDMK
C⊗;
GENERAL
The arm has  six degrees of freedom  corresponding to 6 joints.   The
joints are  numbered from 1 to 6 starting  at the shoulder and moving
out to the  hand. All rotary  joint angles  are measured in  degrees.
Joint 3 which is linear and is measured in inches.

The coordinate system is  referenced to the table top  with the table
lying in the x y plane at z=0 with the z axis pointing vertically up.
The origin is at the far corner of the table. The base of the  arm is
at 20,10 approximately.

The Arm is normally controlled by  specifying  what  happens  to  the
hand. The program checks that the hand will not intersect the table.

On  the  finger  tips  are  two touch sensors which can interrupt arm
operation.

The  program  which runs the arm is in the form of an interpreter and
works in two basic modes: Planning and  Execution.  In  the  planning
mode  arm  functions are assembled into a data file which may then be
executed by a "DO" command. Functions may be immediately executed  by
prefixing the function call by "DO". For example.

	OPEN 3
	PARK
	DO

will cause a  data file to  be constructed, either  on the 3330  as a
file YELLOW.TRJ or on the Swapping disk, containing the two functions
open the hand to 3 inches  and then move to the park position.  These
two commands are then executed by the DO.

	DO OPEN 3
	DO PARK

This will have the same effect except  that the planning program will
be activated between each function call,  which is time consumming.

It is possible to write symbolic  programs  either  in  the  form  of
macros  using  the "DEFINE" pseudo op, or by creating a text file and
reading it in by a "REQUIRE" pseudo op.

What follows is a list of the Functions, Errors and how  to  run  the
arm. Note tha arm program does not respond to lower case characters.
DO <function> |  DO <program> |  DO If DO  is followed by  a function
then that  function will be executed. This  does not change the state
of any program being compiled. Otherwise the <id> following the DO is
taken as  the program name.   If DO is  terminated by a C/R  then the
default  program is executed. If  this does not  exist the servo will
return an error status 3.  The default program name  is YELLOW and is
changed  by DOing  another program,  in which  case its  program name
becomes the default, or by a BEGIN pseudo op.

REQUIRE <file spec>
This causes the input scanner to read from the designated file.  When
an  EOF  is encountered scan returns to the TTY. <file spec>::= <file
name>.<ext>[pppn] where if <ext> is null then  YEL  is  used  and  if
[pppn] is missing the running pppn is assumed.

DUMP <file spec>
This causes a file to be  opened  and  all  transforms,  vectors  and
macros  are  written  out  in  symbolic  form.  It is the opposite to
REQUIRE.  If  a  file  already  exists,  of  the  same  name,  it  is
over-written!!!

TRANS <id>
<X> <Y> <Z> <O> <A> <T>
This pseudo op is  on  two  lines  and  is  used  to  set  up  a  4x4
transformation  and  to identify it with an <id>. The <X> <Y> and <Z>
specify the position of a point centrally located between the  finger
tips in table coordinates. <O> <A> and <T> specify the orientation of
the hand. with all three angles (in degrees) zero the hand points  in
the  negative  "y"  direction with the fingers in a horizontal plane.
the orientation vector which points from one finger tip to the  other
is  aligned  along  the  "x"  axis.  <O>  specifies a rotation of the
orientation vector about a vertical direction; thus at <O>=90 degrees
the  hand  still  horizontal  would  point  along  the  positive  "x"
direction. <A> is a  rotation  about  the  orientation  vector.  With
<A>=90  degrees  the hand always points straight down. <T> is a final
rotation about the axis of the wrist and corresponds to a rotation of
the  final  joint.  When talking to the interpreter directly from the
TTY only as many parameters that have changed  need  to  be  retyped.
Further  a  delimiter  (which  includes  a  space) indicates that the
parameter is to remain unchanged.  For  example  to  change  the  <Z>
parameter only one types
TRANS <id>
<space><space><Z>C/R.

VECT <id>
<X> <Y> <Z>
This is similar to TRANS except that it sets up  vectors.  There  are
four predeclared vectors X,Y,Z,and NIL the null vector.

BEGIN <id>
This pseudo op starts a program of name <id>. If this  pseudo  op  is
not  given before any instruction then a default BEGIN <default name>
is automatically generated.

END
This closes the trajectory file. If a  program  has  not  been  ENDed
before a DO <program> is executed an automatic END is performed.

WAIT <message>
Causes the arm to  stop at the corresponding point  during execution.
Any  message string, limited  to about  60 characters, is  typed out.
Execution may be resumed (after executing any number of functions) by
a proceed command.

P <integer>
this causes the arm to proceed from a wait or an error state, if  the
argument  is  non  zero  execution  proceeds with the last or current
instruction, otherwise from the next instruction.

WHERE <id>
If <id> is  null then this causes the  arm's position to be  read and
the position, joint  angles and hand opening to be typed out. If <id>
is not null then it is assumed to be the name of a save  cell and its
value is typed  out instead. This function  is automatically executed
when  the program is started.  It should only be  executed if the arm
has been moved manually.

HERE <trans> | HERE <trans> <dx> <fac> <axis> <deg>
This is like TRANS except that the hands position is read as in WHERE
to  give the initial position for the transform <id>. Its main use is
in defining  positions  by  moving  the  hand  and  then  creating  a
transform  to  represent the present position. In the second form the
the value of the transform is such that when the vector  <dx>  scaled
by  <fac>  is  added  to it and the transform is rotated about <axis>
<deg> degrees the current hand position is obtained.

PARK
Generates  a  trajectory to the PARK position, which has joint angles
-180, -90, 14, -90, 90, 0

GOTO <trans> | GOTO <trans> <dx> <fac> <axis> <deg>
Generates  a three part trajectory to either <trans> or in the second
case to <trans> rotated about a  vector  <axis>,  <deg>  degrees  and
translated an additional vector <dx> scaled by <fac>.

GO <trans> | GO <trans> <dx> <fac> <axis> <deg>
This is the  same as GOTO  except that it is  a one part  direct move
with no lift off or set down.

MOVE <trans> | MOVE <trans> <dx> <fac> <axis> <deg>
This is the  same as GOTO except  that a smooth trajectory  is fitted
through the three positions.

DRAW <pos> <rot> <angle> <crank> <axis> <deg> <time> <loop>
This  is  a  controlled  motion of the hand. The hand is moved to its
present position plus the vector <pos>.  As  it  moves  the  hand  is
rotated about a vector <rot>, <angle> degrees. If <crank> is not null
then the hand is assumed to be attached  to  a  crank  which  is  the
initial  position  +  <crank> and as the first motion is executed the
hand attached to the end of the crank is rotated about an axis <axis>
<deg>  degrees.  If  loop  is  non  zero  and  the  initial and final
positions are the same the loop motion may be  repeated  continuously
<loop> times. The entire motion takes <time> jiffies. A jiffy is 1/60
th. second.

CHANGE <dx> <fac> <rot> <deg> <time>
This  causes a differential motion of vector <dx> scaled by <fac> and
simultaneously the hand rotated about a vector <rot>, <deg>  degrees.
If <time> > 0 then the motion shall take <time> jiffies.

DRIVE <joint> <dist> <time>
This causes joint <joint>(1 is the root joint -- 6 is the hand) to be
driven  <dist> degrees,   or  in the  case of  joint 3  ---inches. If
<time> >  0 then  the motion  shall take  <time>  jiffies. All  other
joints brakes remain on unless free joints are also specified.

PLACE
This causes the hand to move down until it meets some resistance.
OPEN <dist>
This causes the hand to be opened or closed until the opening between
the  fingers is <dist>, it gives up after about 4 seconds and returns
error 22 if it is unable to comply.

CLOSE <dist>
This  always  closes the hand until it meets some resistance. It then
checks that the opening of the hand is greater than <dist>. If it  is
less  it returns error 2. This is useful in checking that the hand is
holding something.

CENTER <dist>
This  is  the  same  as CLOSE except that the hand is driven to close
centrally over the object using touch.

SCREW <vel>
This instruction will drive the tool at velocity <vel> (maximum =63).
It must be MERGEd with some arm motion.
i.e.
	SCREW 27
	MERGE
	CHANGE REACH 1 NIL 0 100
While  the  hand reaches one inch the tool will drive at velocity 27.
Normally FREE joints would  also  be  specified  together  with  some
STOPping  constraint.

FREE <n> <f1> ... <fn>
For  each  of  the  <n>  direction vectors <fn> joints of the arm are
freed  during  the  next  arm  motion.  These  joints  have   gravity
compensation,  additional forces and acceleration compensation but no
position sensitive feedback. The vectors <fn> specify  directions  in
table coordinates.

For example.

	FREE 2 X Y
	CHANGE Z -1 NIL 0 100

Would provide for free motion in the x and y direction while the hand
moves down 1 inch for the next 100 jiffies.

SPIN <n> <f1> ... <fn>
For each of the <n> axis vectors <fn> joints of the arm are freed  as
in FREE.

FORCE <fv> <mv>
During the next arm motion additional predicted joint torques will be
applied such as to exert a force <fv> and moment <mv> at the hand.

For example.

	FREE 1 Z
	VECT F
	0 0 -50
	FORCE F NIL
	CHANGE NIL 0 NIL 0 100

This would provide for a direction of free motion in the z  direction
while  exerting  a  force of 50 oz. straight down. i.e. the hand will
push down at 50 oz for the next 100 jiffies.

STOP <fv> <mv>
If during the next arm motion the force and moment at the hand exceed
<fv>  and  <mv>  the  arm  will stop. If such a condition is not meet
during the motion an error 23 will be returned.

WOBBLE <deg>
This  causes  the outer three joints to be perturbed with a sine wave
of amplitude <deg> degrees.

NNUL
At  the  end  of the next motion do not wait to null out joint errors
but stop the arm immediately.




CONO <arrive> <weight> <k> <ts> <tm>
This function executed  immediately before any motion  instruction is
used to  modify the performance of that  motion. All motions start at
an initial position move  to a position  given by initial +  <depart>
where <depart>  is a vector which  is set to the  last <arrive> after
each  motion instruction.  The arm then  moves to a position given by
final + <arrive>,  and then to  the final position.   In the case  of
PARK <arrive>  is set to null.   A vector <k> is used  to specify the
radii of gyration  of the object  held in the  hand.  the  x axis  is
along  the direction  normal  to  the plane  of  the fingers.  the  y
direction is  along the direction of  the orientation vector (between
the finger  tips). and  the z  direction is  along  the fingers.  The
weight  of the  object is  given  in <weight>  in ounces.   <ts>,  if
positive,   is  the  minimum time  in jiffies  (1/60 second)  for the
initial and final parts of the trajectory, and <tm>, if positive,  is
the minimum time  for the mid part.  non zero  times are used to slow
down arm motions.

MERGE
This  function  if  executed  before  a motion instruction causes the
instruction before the motion instruction to  be  executed  with  the
motion.  This  is  only useful with OPEN if it is desired to open the
hand as it moves off.
i.e
	OPEN 3
	MERGE
	MOVE T
will cause the hand to start opening as the arm starts to move.

TOUCH <mask>
This causes the arm to stop during the next instruction if any of the
masked touch sensors in <mask> are activated.
i.e.
	TOUCH 3
	OPEN 0
will  cause  the  hand  to  close  until  it touches something. If it
touches anything an error <mask>&6 is returned where <mask> are those
sensors which have been activated.
SAVE <id>
The current deviation in position and orientation  from the set point
is  saved in  cell  <id>. for  example  if the  hand were  move  to a
position T and then  CENTERed the deviation  of position of the  hand
from T,  after the centering operation can be saved in <id>
i.e.
	MOVE T
	CENTER 1
	SAVE C1

SET <id> <t1> <t2>
This will preload  cell <id> with  the deviation to  produce position
and  orientation <t1>  when told  to move  to <t2>,  if this  cell is
RESTOREd with the move.

RESTORE <id> <int>
This instruction must be executed immediately  after  a  MOVE  or  GO
instruction and will cause the hand to move to the position specified
plus the deviation. SAVEd in cell <id>. If <int> is non zero the cell
will be freed for further use.
i.e.
	MOVE T
	RESTORE C1 1
will cause the  hand to move to T  plus the position SAVEd in  C1. It
will also free up C1 for further use.
 JUMP <label>
All instructions may be labelled by a label followed by a colon,  and
the JUMP instruction will cause control to jump to that instruction.
i.e.
L1:	MOVE T
	PARK
	JUMP L1
will cause an infinite loop.

SKIPE <error>
If error <error> occurs during execution on the previous  instruction
then the following instruction is skipped.
i.e.
L1:	OPEN 3
	CHANGE REACH 1 NIL 0 0
	CLOSE 1
	SKIPE 2
	JUMP L2
	JUMP L1
L2:
will  cause  the hand to advance by inches snapping its jaws until it
finds something wider than 1 inch.

SKIPN <error>
The same as SKIPE except that it skips only  if  the  error  did  not
occur. Which makes the last example cleaner.
L1:	OPEN 3
	CHANGE REACH 1 NIL 0 0
	CLOSE 1
	SKIPN 2
	JUMP L1

SKIPS <error>
This is like SKIPE in that the right octal digit of  the  error  must
match  exactly  but it also requires that the logical AND of the high
order digits with <error> is true. This is mostly used in touch work.
For  example if either error 46 or error 16 would indicate some state
then a SKIPS 56 would detect it.

ASSIGN <id> <integer>
This is  an  assignment statement  which can  be used  at runtime  in
conjunction with the SOJG instrution.

SOJG <id> <label>
This  instruction  Subtract  and  Jump  if  Greater  than  zero  will
decrement  an  assign cell  an  jump to  the  label if  the  count is
positive.

AOJ <label>
This  is  the  same  as JUMP except that it will perform a spiral box
search as follows. A SEARCH command must have first been executed  to
calculate the differential joint angle changes to make an x deviation
and a y deviation at the place that the search must be executed. Then
every  time  the  AOJ  instruction  is  executed  it first performs a
RESTORE of appropriate magnitude to  generate  the  spiral  and  then
performs the JUMP.
i.e.
	MOVE T
	SEARCH 1 Z X
L1:	MOVE T
	AOJ L1
Will cause a spiral search in one inch steps. The first move to T  is
important as the context for the SEARCH must be established.

SEARCH <step> <normal> <first_step>
Computes the change in  joint angles to conduct a search,  in a plane
normal to  <normal> starting in the direction <first_step>,from where
the arm is currently planned to be and zeros the AOJ counters.

FLUSH
Due  to  the  partial paging scheme used by the arm, Jumps must occur
within pages This instruction will cause a new page  to  be  started.
This will soon go away.

DEFINE <macro name> <par>
<body>
This defines a macro of name <macro name> and formal parameters given
by  <par>  a list of identifiers. The body then follows,line by line.
The macro is terminated by a blank line. macros  may  be  nested.  An
example
DEFINE GRAB MIN
MOVE T
CLOSE MIN

If the macro call appears then the expanded code will be assembled.
	GRAB 2
will assemble as
	MOVE T
	CLOSE 2
These macros are written out by the DUMP command and are read  in  by
the REQUIRE command.

ED <macro name>
This is a rudementary editor. The <macro  name>  must  be  given  the
first  time  but  need  not be gived again if the same macro is to be
re-edited. The macro definition is then presented line by line  every
time a C/R is typed. Previous lines may be retrieved by typing ALT.
	A "D" will delete the current line
	An "I" will insert a line after the present line, to be typed
	in.
	A "Z" will give the current line to the line editor.
	A "T" will cause the next line to be typed.
All these commands may be preceded by an unsigned integer which  will
do  n  of  them.  For  example  5D will delete the current and next 4
lines. When you have finished editing the macro  type  "E"  then  the
macro  will  be read in again and redefined. (assuming that the first
line which has the DEFINE is not deleted. This by the way is  a  good
way  to  modify  existing  macros  if the macro name is changed a new
macro will be defined. One additional feature  is  "F"  followed  SOS
manner  by  a  string.  It will then do a series of C/Rs until a line
with a matching string is found.
This  is  a  programming  example.  We have the situation of the hand
holding the screw driver which has a screw on its  end.  We  want  to
insert the screw into a hole and to screw it all the way in.
	DEFINE	SCRW	H A		;The macro to screw the screw
					;into hole H using approach A
	VECT SA				;The  departure  vector  from
					;the screw dispenser
	0 -1 2
	VECT SCK			;The radii of gyration of the
					;screw driver
	.5 1.0 1.0
	CONO A SCK 50 10 40		;Set  up  the  conditions for
					;the move
	FIND H H 1			;A   nested   macro  call  to
					;perform the search
	VECT FV				;The  force to verify that it
					;is in the hole
	0 0 -60
	STOP FV NIL			;Stop during the next motion
	CHANGE Z -.7 NIL 0 0		;If the arm goes .7 inch then
					;we are not
					;in the hole and the arm will
					;stop with error 23
	FREE 3 X Y Z			;X, Y and Z  are  vectors  in
					;the x, y and  z  directions.
					;This   will    specify    of
					;freedom.
	VECT FV				;We will wnat  to  push  down
					;with this force
	0 0 -60
	FORCE FV NIL			;Push with force FV
	VECT MV				;This is the stopping moment
	0 0 -100
	STOP NIL MV			;Stop when we meet it.
	SCREW 60			;Drive  the  screw  driver at
					;this velocity
	MERGE				;while
	CHANGE NIL 0 NIL 0 100		;we  go nowhere while pushing
					;down,    with   three   free
					;joints,    monitoring    the
					;torque.
L1:	FREE 2 X Y			;The  screw  is now in and we
					;must  pull  the screw driver
					;out. We want two
	WOBBLE .2			;Shake things around a bit
	CHANGE Z .2 NIL 0 0		;while we go up 0.2 inches
	VECT FV				;Set up a force
	0 0 100
	STOP FV NIL			;and  stop  if it is exceeded
					;during   the   next  motion,
					;indicating that  the  driver
					;is jammed in the screw.
	NNUL				;dont null errors
	CHANGE Z 1 NIL 0 50		;and try to go up an inch.
	SKIPE 23			;this means that the stopping
					;force of 100 oz was not meet
					;and all is O.K.
	JUMP L1				;if not try again
	GO SC				;and go back to the dispenser
	DEFINE	FIND	T D F		;This macro is used to search
					;for  the hole The hole is at
					;Trans T offset by a vector D
					;scaled by F
	NNUL				;dont null the first time
	GO T D F NIL 0			;Go to the hole position
	VECT FV				;Maximum  resistance that the
					;screw will meet
	0 0 -50
	SEARCH .07 Z X			;Set  up  for a search of 0.7
					;in   steps.  Note  that  the
					;context  for  the search has
					;been   established   by  the
					;previous GO.
	CONO NIL SCK 10 0 0		;No  arrive  or  depart, move
					;directly
L1:	GO T D F NIL 0			;The search move
	STOP FV NIL			;Try to go down
	NNUL				;without nulling
	CHANGE Z -.6 NIL 0 60		;by 0.6 inches
	SKIPE 23			;if  we  meet resistance then
					;not in hole
	AOJ L1				;spiral and try again

ERRORS
This is a list of the error messages you might get when running the arm.
When running wave the error message corresponding to the error is typed.

	1	Arithmetic Overflow occured. Something bad has happened.
	<n>1	Excessive force occured at joint <n>
	2 	Hand closed more than minimum specified in CLOSE function
	3	File not found
	4	Someone has pawned the DSK
	5	Someone has sold the DSK
	<mask>6	Touch sensors <mask> have touched something
	7	Cannot read the joint positions, usually hardware trouble.
	20	Function took too long to execute
	22	Hand function took too long to execute.
	23	Arm failed to reach force limit set by STOP during motion.
	24	Arm in L1: JUMP L1 type loop.
	25	Save array number out of bound
	27	The function you have called is disconnected.
	30	The arm is down
	50	Librascope read error
	60	You have a very old program which does not match the
		current servo
	70	The reference supply used by the arm is off.
	100	The PDP6 is not running.
	200	The servo program has been interrupted.
	500	The arm solution does not exist
	600	No cell set up for SOJG


RUNNING THE ARM
Power  to the arm is controlled by a switch on a box with two lights.
The box is located on the rack under the table near the base  of  the
arm.  The  yellow light indicated that the power supply is on and the
red light indicated that the arm is also on.

There is also a grey box on the end of a cable with some switches and
a  →→→"RED  BUTTON"←←← on it. The buttons are brake releases. The one
furthest from the →→→"RED BUTTON"←←← is joint 1. There  is  no  brake
release  for  joint  6, sorry about that. The last switch is the hand
brake release. All brakes should be turned on when the arm  is  being
run.

Now  for  the →→→"RED BUTTON"←←←. If the →→→"RED BUTTON"←←← is pushed
while the arm is running the arm will stop and  all  brakes  will  be
applied.  You  should always be holding the box with your finger over
the →→→"RED BUTTON"←←← when running the arm. For  damaging  the  hand
...  -6  acamedic  credits.  For  damaging  the  arm ... -12 acamedic
credits.

There is also a bell that starts 1 second before the arm does in  the
case  of  a  DO  and starts with the arm in the case of a P. The bell
goes "ting, ting, ting," just like a truck  backing-up,  except  that
someone stole the bell, oh well!

RUNNING THE PROGRAM
The program is on 1,3 and is run by typing
R YELLOW
This program will in turn log in a servo program as a  PTY  job,  and
will  run  a  job  called ARM-Y. When this job is running you will be
asked if you want your files saved. If you respond  Y  then  the  arm
programs  will be written out on the 3330 with .TRJ extensions. These
files may be executed at a later time by simply saying DO followed by
the  file  name(with  no  extension).  If you do not ask to have your
files saved fast bands will be used  which  although  fast  will  all
disappear when you kill your job.

Wave will then announce that it is ready and you can type anything on
the  previous pages.   It will  respond with O.K.   when it  has been
supplied all the  parameters for  the function you  are defining.  It
will  then respond  with  an  * when  ready  for  the next  function.
Sometimes  in execution the servo program  will cause trouble. If you
do do  not get  a response  from the servo  program you  can type  ↑C
followed by REE. If you were indeed waiting for the servo program you
will be back talking to  the main program and  will have a new  servo
program running, if not  you will be in the SAIL  ALLOC mechanism and
will have lost all your data.